package com.bckj.fastboot.upms.api.util.dict;

import cn.hutool.cache.Cache;
import cn.hutool.cache.CacheUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.spring.SpringUtil;
import com.bckj.fastboot.upms.api.entity.SysDict;
import com.bckj.fastboot.upms.api.service.SysDictRemoteService;

import java.util.List;
import java.util.Optional;

public class DictResolver {

    /** 缓存时间 600秒 */
    private static final long CACHE_EFFECTIVE_TIME = 600;
    private static final Cache<String, Object> DICT_CACHE = CacheUtil.newFIFOCache(50);

    /**
     * 根据字典类型获取所有字典项
     * @param type 字典类型
     * @return 字典数据项集合
     */
    public static List<SysDict> listByType(String type) {
        Assert.notBlank(type, "参数不合法");
        return SpringUtil.getBean(SysDictRemoteService.class).listByType(type);
    }

    /**
     * 根据字典类型以及字典项编码获取字典
     * @param type 字典类型
     * @param code 字典项编码
     * @return 字典项标签值
     */
    public static Optional<SysDict> getByCode(String type, String code) {
        return DictResolver.loadByCode(type, code);
    }

    private static Optional<SysDict> loadByCode(String type, String code) {
        List<SysDict> list = listByType(type);
        if (CollUtil.isNotEmpty(list)) {
            return list.stream().filter(p -> StrUtil.equals(p.getCode(), code)).findFirst();
        }
        return Optional.empty();
    }


    /**
     * 根据字典类型以及字典项名称获取字典
     * @param type 字典类型
     * @param name 字典项名称
     * @return 字典项标签值
     */
    public static Optional<SysDict> getByName(String type, String name) {
        return  DictResolver.loadByName(type, name);
    }

    private static Optional<SysDict> loadByName(String type, String name) {
        List<SysDict> list = listByType(type);
        if (CollUtil.isNotEmpty(list)) {
            return list.stream().filter(p -> StrUtil.equals(p.getName(), name)).findFirst();
        }
        return Optional.empty();
    }
}